﻿using ConsoleApp1.Entity;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {



            using (AdminDB DbContext = new AdminDB())
            {

                DbContext.Database.Initialize(true);

                var list = DbContext.Users.ToList();
                Console.WriteLine("{0}\t{1}\t{2}\t{3}\t{4}\t{5}\t{6}\t{7}","Id","用户名","密码","是否启用","是否删除","创建时间","删除时间","备注" );
                foreach (var item in list) 
                {
                    Console.WriteLine("{0}\t{1}\t{2}\t{3}\t{4}\t{5}\t{6}\t{7}", item.Id, item.UserName ,item.Pwd, item.IsActived, item.IsDeleted,item.CreatedTime, item.UpdateTime, item.Remarks);
                }

              //  var user = new Users
              //  {
              //      UserName = "aaa",
              //      Pwd = "12345",
              //      IsActived = true,
              //      IsDeleted = false,
              //      CreatedTime = DateTime.Now,
              //      UpdateTime = DateTime.Now,
              //      Remarks = "hhhh"
              //  };

              //  DbContext.Users.Add(user);
              //  DbContext.SaveChanges();
              // Console.ReadLine();

                //  System.Data.Entity.Database.SetInitializer(new DbInit());
            }


            //lambda表达式
            //任何 Lambda 表达式都可以转换为委托类型。 Lambda 表达式可以转换的委托类型由其参数和返回值的类型定义。
            //如果 lambda 表达式不返回值，则可以将其转换为 Action 委托类型之一；否则，可将其转换为 Func 委托类型之一
            Func<int, int> square = x => x * x;
            Console.WriteLine(square(5));
            // Output:
            // 25

            // 表达式 lambda 还可以转换为表达式树类型
            System.Linq.Expressions.Expression<Func<int, int>> e = x => x * x;
            Console.WriteLine(e);
            // Output:
            // x => (x * x)
            //可在需要委托类型或表达式树的实例的任何代码中使用 lambda 表达式
            int[] number = { 2, 3, 4, 5 };
            var squaredNumbers = number.Select(x => x * x);
            Console.WriteLine(string.Join(" ", squaredNumbers));
            // Output:
            // 4 9 16 25




            // 表达式位于 => 运算符右侧的 lambda 表达式称为“表达式 lambda” 。
            //表达式 lambda 广泛用于表达式树的构造。 表达式 lambda 会返回表达式的结果，并采用以下基本形式：

            //(input - parameters) => expression

            //  仅当 lambda 只有一个输入参数时，括号才是可选的；否则括号是必需的。
            //使用空括号指定零个输入参数：

            //Action line = () => Console.WriteLine();

            //   括号内的两个或更多输入参数使用逗号加以分隔：

            //Func<int, int, bool> testForEquality = (x, y) => x == y;

            //   有时，编译器无法推断输入类型。 可以显式指定类型，如下面的示例所示：

            //Func<int, string, bool> isTooLong = (int x, string s) => s.Length > x;

            // 输入参数类型必须全部为显式或全部为隐式；否则，便会生成 CS0748 编译器错误。
            //表达式 lambda 的主体可以包含方法调用。 不过，若要创建在.NET 公共语言运行时的上下文之外
            //（如在 SQL Server 中）计算的表达式树，不得在 lambda 表达式中使用方法调用。 在.NET 公共语言运行时上下文之外，方法将没有任何意义





            //语句 lambda 的主体可以包含任意数量的语句；但是，实际上通常不会多于两个或三个
            Action<string> greet = name =>
            {
                string greeting = $"Hello {name}!";
                Console.WriteLine(greeting);
            };
            greet("World");
            // Output:
            // Hello World!



            //自 C# 7.0 起，C# 语言提供对元组的内置支持。 可以提供一个元组作为 Lambda 表达式的参数，
            //同时 Lambda 表达式也可以返回元组。 在某些情况下，C# 编译器使用类型推理来确定元组组件的类型。
            //可通过用括号括住用逗号分隔的组件列表来定义元组。 下面的示例使用包含三个组件的元组，
            //将一系列数字传递给 lambda 表达式，此表达式将每个值翻倍，然后返回包含乘法运算结果的元组（内含三个组件）

            Func<(int, int, int), (int, int, int)> doubleThem = ns => (2 * ns.Item1, 2 * ns.Item2, 2 * ns.Item3);
            var numbers = (2, 3, 4);
            var doubledNumbers = doubleThem(numbers);
            Console.WriteLine($"The set {numbers} doubled: {doubledNumbers}");
            // Output:
            // The set (2, 3, 4) doubled: (4, 6, 8)

            //通常，元组字段命名为 Item1、Item2 等等。但是，可以使用命名组件定义元组
            Func<(int n1, int n2, int n3), (int, int, int)> doubleThems = ns => (2 * ns.n1, 2 * ns.n2, 2 * ns.n3);
            var num = (2, 3, 4);
            var doubledNum = doubleThems(num);
            Console.WriteLine($"The set {num} doubled: {doubledNum}");




            // 含标准查询运算符的 lambda

            //下面的 Func 委托在调用后返回布尔值，以指明输入参数是否等于 5：

            Func<int, bool> equalsFive = x => x == 5;
            bool result = equalsFive(4);
            Console.WriteLine(result);   // False

            //参数类型为 Expression<TDelegate> 时，也可以提供 Lambda 表达式，
            //例如在 Queryable 类型内定义的标准查询运算符中提供。 指定
            //Expression< TDelegate > 参数时，lambda 编译为表达式树。
            // 下面的示例使用 Count 标准查询运算符：

            int[] a = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };
            var firstNumbersLessThanSix = a.TakeWhile(n => n < 6);
            Console.WriteLine(string.Join(" ", firstNumbersLessThanSix));
            // Output:
            // 5 4 1 3

            // 以下示例通过将输入参数括在括号中来指定多个输入参数
            int[] b = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };
            var firstSmallNumbers =b.TakeWhile((n, index) => n >= index);
            Console.WriteLine(string.Join(" ", firstSmallNumbers));
            // Output:
            // 5 4
        }
    }
}
